package homework.Day0325.tofinal;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;

import com.sun.tools.javac.Main;
import org.junit.Test;

public class InitialToFinal {

  @Test
  public void example01() {
    /*
    初始化
    在以下代码结构中增加代码，不要修改已有的代码
     */
    Node p = null;
    Node r = null;

    /* =====这里是你要新增的内容===== */
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    r = p.next.next;
    /* =====这里是你要新增的内容===== */

    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */
    assertNotNull(p);
    assertNotNull(r);
    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", p.next.next.value);
    assertEquals("3", r.value);
    assertNull(r.next);

    /*
    转换为最终状态的代码
    补全这里的代码
     */

    /* =====这里是你要新增的内容===== */
    p = p.next;
    /* =====这里是你要新增的内容===== */

    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */
    assertNotNull(p);
    assertNotNull(r);
    assertEquals("2", p.value);
    assertEquals("3", p.next.value);
    assertNull(p.next.next);
    assertEquals("3", r.value);
    assertNull(r.next);
  }

  @Test
  public void q02() {
    /*
    初始化
    在以下代码结构中增加代码，不要修改已有的代码
     */
    Node p = null;
    Node q = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    q = p.next;
    r = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", q.value);
    assertEquals("3", r.value);
    assertEquals(p.next, q);
    assertEquals(q.next, r);
    assertNull(r.next);

    /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p = p.next;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */
    assertEquals(p, q);
    assertEquals("2", p.value);
    assertEquals(p.next, r);
    assertEquals("3", p.next.value);
    assertNull(r.next);

  }

  @Test
  public void q03() {
    Node p = null;
    Node q = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    q = p.next;
    r = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", q.value);
    assertEquals("3", r.value);
    assertEquals(p.next, q);
    assertEquals(q.next, r);
    assertNull(r.next);

    /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    q = p;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals(p, q);
    assertEquals("1", p.value);
    assertNotEquals(p.next, q);
    assertEquals("2", p.next.value);
    assertEquals("3", p.next.next.value);
    assertEquals(r, p.next.next);
    assertNull(r.next);
  }


  @Test
  public void q04() {
    Node p = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    r = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", r.value);
    assertEquals(r, p.next.next);
    assertNull(r.next);

    /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    r = p.next;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals(r, p.next);
    assertEquals("1", p.value);
    assertEquals("2", r.value);
    assertEquals("3", r.next.value);
    assertNull(r.next.next);
  }

  @Test
  public void q05() {
    Node p = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    r = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", r.value);
    assertEquals(r, p.next.next);

    /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.value = "3";
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("3", p.value);
    assertNotEquals(p, r);
    assertEquals("3", r.value);
    assertEquals("2", p.next.value);
    assertNull(r.next);
  }

  @Test
  public void q06() {
    Node p = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    r = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */


    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", r.value);
    assertEquals(r, p.next.next);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.value = "3";
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("3", p.value);
    assertNotEquals(p, r);
    assertEquals("3", r.value);
    assertEquals("2", p.next.value);
    assertNull(r.next);
  }


  @Test
  public void q07() {
    Node p = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    r = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", r.value);
    assertEquals(r, p.next.next);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    r.next = p;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertNotEquals(p, r);
    assertEquals(p, r.next);
    assertEquals("3", r.value);
    assertEquals("2", p.next.value);
    assertEquals("2", p.next.next.next.next.value);
    assertNotNull(r.next);
  }


  @Test
  public void q08() {
    Node p = null;
    Node q = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    q = p.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals(q, p.next);
    assertEquals("3", p.next.next.value);
    assertNotNull(p);
    assertNotNull(q);
    assertNotNull(p.next);
    assertNotNull(q.next);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    q.next.next = p;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals(q, p.next);
    assertEquals("3", p.next.next.value);
    assertNotNull(p);
    assertNotNull(q);
    assertNotNull(p.next);
    assertNotNull(q.next);
    assertEquals("2", p.next.value);
    assertEquals("2", p.next.next.next.next.value);

  }

  @Test
  public void q09() {
    Node p = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("1", null);
    p.next = new Node("2", null);
    p.next.next = new Node("3", null);
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", p.next.next.value);
    assertNotNull(p);
    assertNotNull(p.next);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.next.next.next = p;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("1", p.value);
    assertEquals("2", p.next.value);
    assertEquals("3", p.next.next.value);
    assertNotNull(p);
    assertNotNull(p.next);
    assertEquals("2", p.next.value);
    assertEquals("2", p.next.next.next.next.value);

  }



  @Test
  public void q10() {
    Node p = null;
    Node q = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("A", null);
    p.next = new Node("B", null);
    p.next.next = new Node("C", null);
    q = p.next.next;
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertEquals(q, p.next.next);
    assertNotNull(p);
    assertNotNull(q);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.next = p.next.next;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("C", p.next.value);
    assertEquals(q, p.next);
    assertNotNull(p);
    assertNotNull(q);

  }


  @Test
  public void q11() {
    Node p = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("A", null);
    p.next = new Node("B", null);
    p.next.next = new Node("C", null);
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertNotNull(p);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.next = p.next.next;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("C", p.next.value);
    assertNotNull(p);

  }

  @Test
  public void q12() {
    Node p = null;
    Node q = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("B", null);
    p.next = new Node("C", null);

    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("B", p.value);
    assertEquals("C", p.next.value);
    assertNotNull(p);
    assertNull(q);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p = new Node("A",p);
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertNotNull(p);
    assertNull(q);

  }


  @Test
  public void q13() {
    Node p = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("A", null);
    p.next = new Node("B", null);
    p.next.next = new Node("C", null);
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertNotNull(p);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.next.next.next = new Node("D", null);
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertEquals("D", p.next.next.next.value);
    assertNotNull(p);

  }

  @Test
  public void q14() {
    Node p = null;
    Node q = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("A",null);
    p.next = new Node("B",null);
    p.next.next = new Node("C",null);

    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertNotNull(p);
    assertNull(q);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.next.next.next = p;
    p = p.next;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("B", p.value);
    assertEquals("C", p.next.value);
    assertEquals("A", p.next.next.value);
    assertNotNull(p);
    assertNull(q);

  }

  @Test
  public void q15() {
    Node p = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("A",null);
    p.next = new Node("B",null);
    p.next.next = new Node("C",null);
    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertNotNull(p);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO
    p.next.next.next = p;
    p = p.next;
    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("B", p.value);
    assertEquals("C", p.next.value);
    assertEquals("A", p.next.next.value);
    assertNotNull(p);

  }

  @Test
  public void q16() {
    Node p = null;
    Node q = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO

    p = new Node("E",null);
    p.next = new Node("H",null);
    p.next.next = new Node("M",null);
    q = new Node("B",null);
    q.next = new Node("F",null);
    q.next.next = new Node("G",null);
    q.next.next.next = new Node("R",null);

    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("E", p.value);
    assertEquals("H", p.next.value);
    assertEquals("M", p.next.next.value);
    assertNull(p.next.next.next);

    assertEquals("B", q.value);
    assertEquals("F", q.next.value);
    assertEquals("G", q.next.next.value);
    assertEquals("R", q.next.next.next.value);
    assertNull(q.next.next.next.next);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO

    p.next.next.next = q.next.next.next;
    q.next.next.next = p.next;
    p.next = q.next;
    q.next = p;
    p = q;
    q = null;

    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("B", p.value);
    assertEquals("E", p.next.value);
    assertEquals("F", p.next.next.value);
    assertEquals("G", p.next.next.next.value);
    assertEquals("H", p.next.next.next.next.value);
    assertEquals("M", p.next.next.next.next.next.value);
    assertEquals("R", p.next.next.next.next.next.next.value);
    assertNull(p.next.next.next.next.next.next.next);
    assertNull(q);

  }

  @Test
  public void q17() {
    Node p = null;
    Node q = null;
    Node r = null;

    /*
    在这里增加代码，达到初始化结果
     */
    // TODO
    p = new Node("A",null);
    p.next = new Node("B",null);
    p.next.next = new Node("C",null);
    p.next.next.next = new Node("D",null);

    /*
    测试初始化代码
    需要补全初始化代码，通过单元测试，不要修改以下代码
     */

    assertEquals("A", p.value);
    assertEquals("B", p.next.value);
    assertEquals("C", p.next.next.value);
    assertEquals("D", p.next.next.next.value);
    assertNull(p.next.next.next.next);
    assertNull(q);
    assertNull(r);

   /*
    转换为最终状态的代码
    补全这里的代码
     */
    // TODO

    q = p;
    p = p.next.next.next;
    p.next = q.next.next;
    p.next.next = q.next;
    p.next.next.next = q;
    p.next.next.next.next = null;
    q = null;


    /*
    最终状态的单元测试
    补全上面的代码，通过单元测试，不要修改以下代码
     */

    assertEquals("D", p.value);
    assertEquals("C", p.next.value);
    assertEquals("B", p.next.next.value);
    assertEquals("A", p.next.next.next.value);
    assertNull(p.next.next.next.next);
    assertNull(r);
    assertNull(q);

  }
}
